home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Misc / msql-1.0.6 / src / msql / msqld.c < prev    next >
C/C++ Source or Header  |  1995-05-28  |  14KB  |  767 lines
  1. /*
  2. **    msqld.c    - 
  3. **
  4. **
  5. ** Copyright (c) 1993  David J. Hughes
  6. **
  7. ** Permission to use, copy, and distribute for non-commercial purposes,
  8. ** is hereby granted without fee, providing that the above copyright
  9. ** notice appear in all copies and that both the copyright notice and this
  10. ** permission notice appear in supporting documentation.
  11. **
  12. ** This software is provided "as is" without any expressed or implied warranty.
  13. **
  14. ** ID = "$Id:"
  15. **
  16. */
  17.  
  18.  
  19. #include <stdio.h>
  20. #include <fcntl.h>
  21. #include <limits.h>
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #include <sys/time.h>
  25. #include <sys/socket.h>
  26. #include <netinet/in.h>
  27. #include <arpa/inet.h>
  28. #include <stdlib.h>
  29. #include <varargs.h>
  30.  
  31.  
  32. #include "common/portability.h"
  33.  
  34. #ifdef HAVE_SYS_UN_H
  35. #  include <sys/un.h>
  36. #endif
  37.  
  38. #include <signal.h>
  39. #include <netdb.h>
  40.  
  41. #ifdef HAVE_SELECT_H
  42. #  include <select.h>
  43. #endif
  44.  
  45. #ifdef HAVE_SYS_SELECT_H
  46. #  include <sys/select.h>
  47. #endif
  48.  
  49. #include "common/site.h"
  50. #include "common/debug.h"
  51.  
  52. #include "msql_priv.h"
  53. #include "errmsg.h"
  54.  
  55.  
  56.  
  57.  
  58. extern  char    *yytext;
  59. extern    int    yylineno;
  60. extern    int    yydebug;
  61. extern    int    titleFlag;
  62.  
  63. extern    char    errMsg[];
  64.  
  65. int    curSock,
  66.     IPsock,
  67.     UNIXsock,
  68.     numCons;
  69.  
  70. #define MAX_SOCK_NUM    100
  71.  
  72. cinfo_t    conArray[MAX_SOCK_NUM];
  73.  
  74. extern    char    *packet;
  75. char    PROGNAME[] = "msqld",
  76.     BLANK_ARGV[] = "                                                  ";
  77.  
  78. #define safeFree(x)  { if(x){ (void)free(x); x = NULL; } }
  79.  
  80.  
  81. void sigTrap(sig)
  82.     int    sig;
  83. {
  84.     int    clientSock;
  85.  
  86.     fprintf(stderr,"\nHit by a sig %d\n\n",sig);
  87.     clientSock = 3;
  88.     printf("\n\nForced server shutdown due to bad signal!\n\n");
  89.     while(clientSock < MAX_SOCK_NUM)
  90.     {
  91.         if (conArray[clientSock].db)
  92.         {
  93.             printf("Forcing close on Socket %d\n",clientSock);
  94.             shutdown(clientSock,2);
  95.             close(clientSock);
  96.         }
  97.         clientSock++;
  98.     }
  99.     shutdown(IPsock,2);
  100.     close(IPsock);
  101. #ifdef HAVE_SYS_UN_H
  102.     shutdown(UNIXsock,2);
  103.     close(UNIXsock);
  104.     unlink(MSQL_UNIX_ADDR);
  105. #endif
  106.     printf("\n");
  107.     abort();
  108. }
  109.  
  110.  
  111. sendError(fd,err)
  112.     char    *err;
  113. {
  114. #    ifdef DEBUG
  115.         printf("Send error called\n");
  116. #    endif
  117.     if (err)
  118.         sprintf(packet,"-1:%s\n",err);
  119.     else
  120.         sprintf(packet,"-1:%s\n",errMsg);
  121.     writePkt(fd);
  122. }
  123.  
  124. sendOK(fd)
  125. {
  126. #    ifdef DEBUG
  127.         printf("Send OK called\n");
  128. #    endif
  129.     sprintf(packet,"1:\n");
  130.     writePkt(fd);
  131. }
  132.  
  133.  
  134. /****************************************************************************
  135. **     _initServer
  136. **
  137. **    Purpose    : 
  138. **    Args    : 
  139. **    Returns    : 
  140. **    Notes    : 
  141. */
  142.  
  143. initServer()
  144. {
  145.     int    sock,
  146.         tcpPort,
  147.         addrLen;
  148.     struct    sockaddr_in    IPaddr;
  149.     struct    servent        *serv_ptr;
  150.     char    *unixPort,
  151.         *envVar;
  152.  
  153. #ifdef HAVE_SYS_UN_H
  154.     struct    sockaddr_un    UNIXaddr;
  155. #endif
  156.  
  157.     /*
  158.     ** Create an IP socket
  159.     */
  160.     tcpPort = MSQL_PORT;
  161.     if ((serv_ptr = getservbyname("msql", "tcp")))
  162.     {
  163.         tcpPort = serv_ptr->s_port;
  164.     }
  165.     if ((envVar = getenv("MSQL_TCP_PORT")))
  166.     {
  167.         tcpPort = atoi(envVar);
  168.     }
  169.     msqlDebug(MOD_GENERAL,"IP Socket is %d\n",tcpPort);
  170.     IPsock = socket(AF_INET, SOCK_STREAM, 0);
  171.     if (IPsock < 0)
  172.     {
  173.         perror("Can't start server : IP Socket ");
  174.         exit(1);
  175.     }
  176.     (void)bzero(&IPaddr, sizeof(IPaddr));
  177.     IPaddr.sin_family = AF_INET;
  178.     IPaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  179.     IPaddr.sin_port = htons(tcpPort);
  180.     if (bind(IPsock, (struct sockaddr *)&IPaddr, sizeof(IPaddr)) < 0)
  181.     {
  182.         perror("Can't start server : IP Bind ");
  183.         exit(1);
  184.     }
  185.     listen(IPsock,5);
  186.  
  187. #ifdef HAVE_SYS_UN_H
  188.     /*
  189.     ** Create the UNIX socket
  190.     */
  191.     unixPort = MSQL_UNIX_ADDR;
  192.     if ((envVar = getenv("MSQL_UNIX_PORT")))
  193.     {
  194.         unixPort = envVar;
  195.     }
  196.     
  197.     msqlDebug(MOD_GENERAL,"UNIX Socket is %s\n",unixPort);
  198.     UNIXsock = socket(AF_UNIX, SOCK_STREAM, 0);
  199.     if (UNIXsock < 0)
  200.     {
  201.         perror("Can't start server : UNIX Socket ");
  202.         exit(1);
  203.     }
  204.     (void)bzero(&UNIXaddr, sizeof(UNIXaddr));
  205.     UNIXaddr.sun_family = AF_UNIX;
  206.     strcpy(UNIXaddr.sun_path, unixPort);
  207.     unlink(unixPort);
  208.     if (bind(UNIXsock, (struct sockaddr *)&UNIXaddr, sizeof(UNIXaddr)) < 0)
  209.     {
  210.         perror("Can't start server : UNIX Bind ");
  211.         exit(1);
  212.     }
  213.     listen(UNIXsock,5);
  214. #endif
  215. }
  216.  
  217.  
  218.  
  219. RETSIGTYPE puntServer(sig)
  220.     int    sig;
  221. {
  222.     int    clientSock;
  223.  
  224.     clientSock = 3;
  225.     if (sig == -1)
  226.     {
  227.         printf("\n\nNormal Server shutdown!\n\n");
  228.     }
  229.     else
  230.     {
  231.         printf("\n\nServer Aborting!\n\n");
  232.     }
  233.     while(clientSock < MAX_SOCK_NUM)
  234.     {
  235.         if (conArray[clientSock].db)
  236.         {
  237.             printf("Forcing close on Socket %d\n",clientSock);
  238.             shutdown(clientSock,2);
  239.             close(clientSock);
  240.         }
  241.         clientSock++;
  242.     }
  243.     shutdown(IPsock,2);
  244.     close(IPsock);
  245.  
  246. #ifdef HAVE_SYS_UN_H
  247.     shutdown(UNIXsock,2);
  248.     close(UNIXsock);
  249.     unlink(MSQL_UNIX_ADDR);
  250. #endif
  251.     printf("\n");
  252.     dropCache();
  253.  
  254.     if (debugSet(MOD_MALLOC))
  255.     {
  256.         fprintf(stderr,"\n\nmalloc() leak detection .....\n");
  257.         checkBlocks(MALLOC_BLK);
  258.     }
  259.     if (debugSet(MOD_MMAP))
  260.     {
  261.         fprintf(stderr,"\n\nmmap() leak detection .....\n");
  262.         checkBlocks(MMAP_BLK);
  263.     }
  264.     printf("\n\nmSQL Daemon Shutdown Complete.\n\n");
  265.     if (sig >= 0)
  266.     {
  267.         exit(1);
  268.     }
  269. }
  270.  
  271.  
  272.  
  273. yyerror(s)
  274.         char    *s;
  275. {
  276.      sprintf(packet,"-1:%s near \"%s\"\n", s, yytext?yytext:"");
  277.     writePkt(curSock);
  278.     msqlClean();
  279. }
  280.  
  281.  
  282.  
  283.  
  284.  
  285. static int curComSock;
  286. static fd_set *clientFdSet;
  287.  
  288. static setConnectionState(sock, fds)
  289.     int    sock;
  290.     fd_set    *fds;
  291. {
  292.     curComSock = sock;
  293.     clientFdSet = fds;
  294. }
  295.  
  296.  
  297. RETSIGTYPE puntClient(sig)
  298.     int    sig;
  299. {
  300.     if (clientFdSet)
  301.     {
  302.         FD_CLR(curComSock, clientFdSet);
  303.         shutdown(curComSock,2);
  304.         close(curComSock);
  305.         if (conArray[curComSock].db)
  306.         {
  307.             safeFree(conArray[curComSock].db);
  308.             safeFree(conArray[curComSock].host);
  309.             safeFree(conArray[curComSock].user);
  310.         }
  311.         conArray[curComSock].db = NULL;
  312.         printf("Forced close of client on socket %d due to pipe sig\n",
  313.             curComSock);
  314.         numCons--;
  315.     }
  316. }
  317.  
  318.  
  319. char    *Arg0;
  320.  
  321. void setProcTitle(va_alist)
  322.         va_dcl
  323. {
  324.     va_list args;
  325.     char    msg[1024],
  326.         *fmt;
  327.     int     module;
  328.  
  329.     if (!titleFlag)
  330.         return;
  331.     va_start(args);
  332.     fmt = (char *)va_arg(args, char *);
  333.     if (!fmt)
  334.         return;
  335.     strcpy(msg,"mSQL : ");
  336.     (void)vsprintf(msg + strlen(msg),fmt,args);
  337.     va_end(args);
  338.     if (strlen(msg) > 50)
  339.     {
  340.         *(msg+50) = 0;
  341.     }
  342.     strcpy(Arg0,BLANK_ARGV);
  343.     strcpy(Arg0,msg);
  344. }
  345.  
  346. initProcTitle(argv)
  347.     char    *argv[];
  348. {
  349.     
  350.     if (!titleFlag)
  351.         return;
  352.     Arg0 = argv[0];
  353.     setProcTitle("Starting");
  354. } 
  355.  
  356. setupSignals()
  357. {
  358. #ifdef SIGSEGV
  359.     signal(SIGSEGV,sigTrap);
  360. #endif
  361. #ifdef SIGBUS
  362.     signal(SIGBUS,sigTrap);
  363. #endif
  364. #ifdef SIGINT
  365.     signal(SIGINT,puntServer);
  366. #endif
  367. #ifdef SIGQUIT
  368.     signal(SIGQUIT,puntServer);
  369. #endif
  370. #ifdef SIGKILL
  371.     signal(SIGKILL,puntServer);
  372. #endif
  373. #ifdef SIGPIPE
  374.     signal(SIGPIPE,puntClient);
  375. #endif
  376. }
  377.  
  378.  
  379.  
  380. main(argc,argv)
  381.     int    argc;
  382.     char    *argv[];
  383. {
  384.     fd_set    readFDs,
  385.         clientFDs;
  386.     int    sock,
  387.         newSock,
  388.         comSock,
  389.         command,
  390.         opt,
  391.         sig,
  392.         error;
  393.     char    dbname[30],
  394.         *uname,
  395.         *cp,
  396.         *prog,
  397.         *arg,
  398.         path[255];
  399.     FILE    *pidFile;
  400.  
  401.     /*
  402.     ** See if we have to re-exec ourselves for procTitle space
  403.     */
  404.     if (titleFlag)
  405.     {
  406.         if (*argv[0] != ' ')
  407.         {
  408.             prog = argv[0];
  409.             argv[0] = BLANK_ARGV;
  410.             execvp(prog,argv,argc);
  411.             perror("Exec failed");
  412.             exit(1);
  413.         }
  414.     }
  415.  
  416.  
  417.     /*
  418.     ** We have enough space for fiddling with the argv, continue
  419.     */
  420.     msqlHomeDir = (char *)getenv("MSQL_HOME");
  421.     if (!msqlHomeDir)
  422.     {
  423.         msqlHomeDir = INST_DIR;
  424.     }
  425.     umask(0);
  426.     numCons=0;
  427.     chdir(msqlHomeDir);
  428.     initDebug();
  429.     initNet();
  430.     initServer();
  431.     initBackend();
  432.     initProcTitle(argv);
  433.     (void)sprintf(path,"%s/msqld.pid",PID_DIR);
  434.     pidFile = fopen(path,"w");
  435.     if (!pidFile)
  436.     {
  437.         perror("Couldn't open PID file");
  438.     }
  439.     else
  440.     {
  441.         fprintf(pidFile,"%d",getpid());
  442.         fclose(pidFile);
  443.     }
  444.     chmod(path,0744);
  445.     umask(0);
  446.     setupSignals();
  447.     msqlLoadAcl(1);
  448.     (void)bzero(&clientFDs,sizeof(fd_set));
  449.     msqlDebug(MOD_GENERAL,"miniSQL debug mode.  Waiting for connections.\n");
  450.     while(1)
  451.     {
  452.         (void)bzero(&readFDs,sizeof(fd_set));
  453.         (void)bcopy(&clientFDs,&readFDs,sizeof(fd_set));
  454.         FD_SET(IPsock,&readFDs);
  455. #ifdef HAVE_SYS_UN_H
  456.         FD_SET(UNIXsock,&readFDs);
  457. #endif
  458.         setProcTitle("Idle - %d clients",numCons);
  459.         if(select(MAX_SOCK_NUM+1,&readFDs,0,0,0) < 0)
  460.             continue;
  461.  
  462.         /*
  463.         ** Is this a new connection request
  464.         */
  465.  
  466.         sock = 0;
  467.         if (FD_ISSET(IPsock,&readFDs))
  468.         {
  469.             sock = IPsock;
  470.         }
  471. #ifdef HAVE_SYS_UN_H
  472.         if (FD_ISSET(UNIXsock,&readFDs))
  473.         {
  474.             sock = UNIXsock;
  475.         }
  476. #endif
  477.         if (sock)
  478.         {
  479.             struct    sockaddr_in cAddr;
  480.             int    cAddrLen;
  481.  
  482.             cAddrLen = sizeof(struct sockaddr_in);
  483.             newSock = accept(sock, (struct sockaddr *)&cAddr, 
  484.                 &cAddrLen);
  485.             if(newSock < 0)
  486.             {
  487.                 perror("Error in accept ");
  488.                 continue;
  489.             }
  490.             if (conArray[newSock].db)
  491.             {
  492.                 safeFree(conArray[newSock].db);
  493.                 safeFree(conArray[newSock].host);
  494.                 safeFree(conArray[newSock].user);
  495.                 conArray[newSock].db = NULL;
  496.             }
  497.  
  498.             /*
  499.             ** Are we over the connection limit
  500.             */
  501.             numCons++;
  502.             if (numCons > MAX_CON)
  503.             {
  504.                 numCons--;
  505.                 sendError(newSock,CON_COUNT_ERROR);
  506.                 shutdown(newSock,2);
  507.                 close(newSock);
  508.                 continue;
  509.             }
  510.  
  511.  
  512.             /*
  513.             ** store the connection details
  514.             */
  515.  
  516.             msqlDebug(MOD_GENERAL,"New connection received on %d\n",
  517.                 newSock);
  518.             error = 0;
  519.             if (sock == IPsock)
  520.             {
  521.                 int    addrLen;
  522.                 struct    hostent *hp;
  523.  
  524.                 addrLen = sizeof(struct sockaddr);
  525.                 getpeername(newSock, (struct sockaddr *)
  526.                     &conArray[newSock].remote, &addrLen);
  527.                 addrLen = sizeof(struct sockaddr);
  528.                 getsockname(newSock, (struct sockaddr *)
  529.                     &conArray[newSock].local, &addrLen);
  530.                 hp = (struct hostent *)gethostbyaddr(
  531.                     (char *)&conArray[newSock].remote.sin_addr,
  532.                     sizeof(conArray[newSock].remote.sin_addr),
  533.                     AF_INET);
  534.                 if (!hp)
  535.                 {
  536.                     sendError(newSock, BAD_HOST_ERROR);
  537.                     error = 1;
  538.                     shutdown(newSock,2);
  539.                     close(newSock);
  540.                     
  541.                 }
  542.                 else
  543.                 {
  544.                     conArray[newSock].host = (char *)
  545.                         strdup(hp->h_name);
  546.                     msqlDebug(MOD_GENERAL,"Host = %s\n",
  547.                         hp->h_name);
  548.                 }
  549.             }
  550.             else
  551.             {
  552.                 conArray[newSock].host = NULL;
  553.                 bzero(&conArray[newSock].local,
  554.                     sizeof(struct sockaddr));
  555.                 bzero(&conArray[newSock].
  556.                     remote,sizeof(struct sockaddr));
  557.                 msqlDebug(MOD_GENERAL,"Host = UNIX domain\n");
  558.             }
  559.  
  560.             if (!error)
  561.             {
  562.                 opt=1;
  563.                 setsockopt(newSock,SOL_SOCKET,SO_KEEPALIVE,
  564.                     (char *) &opt, sizeof(opt));
  565.                 sprintf(packet,
  566.                     "0:%d:%s\n",
  567.                     PROTOCOL_VERSION,SERVER_VERSION);
  568.                 writePkt(newSock);
  569.                 if (readPkt(newSock) <=0)
  570.                 {
  571.                     sendError(newSock,HANDSHAKE_ERROR);
  572.                     shutdown(newSock,2);
  573.                     close(newSock);
  574.                     conArray[newSock].host = NULL;
  575.                                     bzero(&conArray[newSock].local,
  576.                                             sizeof(struct sockaddr));
  577.                                     bzero(&conArray[newSock].
  578.                                             remote,sizeof(struct sockaddr));
  579.  
  580.                 }
  581.                 else
  582.                 {
  583.                     FD_SET(newSock,&clientFDs);
  584.                     uname = (char *)strtok(packet,"\n");
  585.                     msqlDebug(MOD_GENERAL,"User = %s\n",uname);
  586.                     conArray[newSock].user = (char *)
  587.                         strdup(uname);
  588.                     sprintf(packet,"-100:\n");
  589.                     writePkt(newSock);
  590.                 }
  591.             }
  592.             continue;
  593.         }
  594.  
  595.     
  596.  
  597.         /*
  598.         ** This must be a command.
  599.         */    
  600.  
  601.         comSock = 3;
  602.         while(comSock < MAX_SOCK_NUM)
  603.         {
  604.             if (FD_ISSET(comSock,&readFDs))
  605.             {
  606.             setConnectionState(comSock,&clientFDs);
  607.             if (readPkt(comSock) <= 0)
  608.                 command = QUIT;
  609.             else
  610.                 command = atoi(packet);
  611.             msqlDebug(MOD_GENERAL,"Command on sock %d = %d (%s)\n",
  612.                 comSock, command, comTable[command]);
  613.             switch(command)
  614.             {
  615.                 case INIT_DB:
  616.                 setProcTitle("Init DB");
  617.                 cp=(char *)strtok(packet+2,"\n\r");
  618.                 strcpy(dbname,cp);
  619.                 msqlDebug(MOD_GENERAL,"DBName = %s\n", dbname);
  620.                 conArray[comSock].access = msqlCheckAccess(
  621.                     dbname, conArray + comSock);
  622.                 if(conArray[comSock].access == NO_ACCESS)
  623.                 {
  624.                     sendError(comSock, 
  625.                         ACCESS_DENIED_ERROR);
  626.                     break;
  627.                 }
  628.                 if (msqlInit(dbname) < 0)
  629.                 {
  630.                     sendError(comSock,NULL);
  631.                 }
  632.                 else
  633.                 {
  634.                     sendOK(comSock);
  635.                     conArray[comSock].db =
  636.                         (char *)strdup(dbname);
  637.                     msqlSetDB(dbname);
  638.                 }
  639.                 break;
  640.  
  641.                 case QUERY:
  642.                 if (!conArray[comSock].db)
  643.                 {
  644.                     sendError(comSock,NO_DB_ERROR);
  645.                     break;
  646.                 }
  647.                 curSock = comSock;
  648.                 cp=(char *)(packet+2);
  649.                 arg = (char *)strdup(cp);
  650.                 if (debugSet(MOD_QUERY))
  651.                     fprintf(stderr,"\n");
  652.                 msqlDebug(MOD_QUERY,"Query = %s",arg);
  653.                 msqlSetDB(conArray[comSock].db);
  654.                 msqlSetPerms(conArray[comSock].access);
  655.                 msqlParseQuery(arg,comSock);
  656.                 safeFree(arg);
  657.                 break;
  658.  
  659.                 case DB_LIST:
  660.                 setProcTitle("DB List");
  661.                 curSock = comSock;
  662.                 msqlListDBs(comSock);
  663.                 break;
  664.  
  665.                 case TABLE_LIST:
  666.                 setProcTitle("Table List");
  667.                 if (!conArray[comSock].db)
  668.                 {
  669.                     sendError(comSock, NO_DB_ERROR);
  670.                     break;
  671.                 }
  672.                 curSock = comSock;
  673.                 msqlListTables(comSock,conArray[comSock].db);
  674.                 break;
  675.  
  676.                 case FIELD_LIST:
  677.                 setProcTitle("Field List");
  678.                 if (!conArray[comSock].db)
  679.                 {
  680.                     sendError(comSock,NO_DB_ERROR);
  681.                     break;
  682.                 }
  683.                 cp=(char *)strtok(packet+2,
  684.                     "\n\r");
  685.                 arg = (char *)strdup(cp);
  686.                 curSock = comSock;
  687.                 msqlListFields(comSock,
  688.                     arg,conArray[comSock].db);
  689.                 break;
  690.  
  691.                 case QUIT:
  692.                 msqlDebug(MOD_GENERAL,"DB QUIT!\n");
  693.                 FD_CLR(comSock,&clientFDs);
  694.                 shutdown(comSock,2);
  695.                 close(comSock);
  696.                 if (conArray[comSock].db)
  697.                 {
  698.                    safeFree(conArray[comSock].db);
  699.                    safeFree(conArray[comSock].host);
  700.                    safeFree(conArray[comSock].user);
  701.                 }
  702.                 conArray[comSock].db = NULL;
  703.                 numCons--;
  704.                 break;
  705.         
  706.                 case CREATE_DB:
  707.                 setProcTitle("Create DB");
  708.                 if (!msqlCheckLocal(conArray + comSock))
  709.                 {
  710.                     sendError(comSock,PERM_DENIED_ERROR);
  711.                     break;
  712.                 }
  713.                 cp=(char *)strtok(packet+2,
  714.                     "\n\r");
  715.                 arg = (char *)strdup(cp);
  716.                 msqlCreateDB(comSock,arg);
  717.                 break;
  718.  
  719.                 case DROP_DB:    
  720.                 setProcTitle("Drop DB");
  721.                 if (!msqlCheckLocal(conArray + comSock))
  722.                 {
  723.                     sendError(comSock,PERM_DENIED_ERROR);
  724.                     break;
  725.                 }
  726.                 cp=(char *)strtok(packet+2,
  727.                     "\n\r");
  728.                 arg = (char *)strdup(cp);
  729.                 msqlDropDB(comSock,arg);
  730.                 break;
  731.  
  732.                 case RELOAD_ACL:
  733.                 setProcTitle("Reload ACL");
  734.                 if (!msqlCheckLocal(conArray + comSock))
  735.                 {
  736.                     sendError(comSock,PERM_DENIED_ERROR);
  737.                     break;
  738.                 }
  739.                 (void)sprintf(packet,"-100:\n");
  740.                 reloadAcls(comSock);
  741.                 writePkt(comSock);
  742.                 break;
  743.  
  744.                 case SHUTDOWN:
  745.                 setProcTitle("Shutdown");
  746.                 if (!msqlCheckLocal(conArray + comSock))
  747.                 {
  748.                     sendError(comSock,PERM_DENIED_ERROR);
  749.                     break;
  750.                 }
  751.                 sprintf(packet,"-100:\n");
  752.                 writePkt(comSock);
  753.                 puntServer(-1);
  754.                 exit(0);
  755.                 break;
  756.  
  757.                 default:
  758.                 sendError(comSock, UNKNOWN_COM_ERROR);
  759.                 break;
  760.             }
  761.             msqlDebug(MOD_GENERAL,"Command Processed!\n");
  762.             }
  763.             comSock++;
  764.         }
  765.     }
  766. }
  767.